home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / rpc / rpcClient.h < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-19  |  7.3 KB  |  229 lines
  1. /*
  2.  * rpcClient.h --
  3.  *
  4.  *    Definitions for the client side of the RPC system.  The main object
  5.  *    here is the Client Channel that keeps state during an RPC.
  6.  *
  7.  * Copyright (C) 1985 Regents of the University of California
  8.  * All rights reserved.
  9.  *
  10.  *
  11.  * $Header: /cdrom/src/kernel/Cvsroot/kernel/rpc/rpcClient.h,v 9.9 92/12/13 18:21:31 mgbaker Exp $ SPRITE (Berkeley)
  12.  */
  13.  
  14. #ifndef _RPCCLIENT
  15. #define _RPCCLIENT
  16.  
  17. #include <netEther.h>
  18. #ifdef KERNEL
  19. #include <net.h>
  20. #include <sync.h>
  21. #include <timer.h>
  22. #include <rpcTypes.h>
  23. #include <rpcPacket.h>
  24. #include <rpcCltStat.h>
  25. #include <rpcHistogram.h>
  26. #else
  27. #include <kernel/net.h>
  28. #include <kernel/sync.h>
  29. #include <kernel/timer.h>
  30. #include <kernel/rpcTypes.h>
  31. #include <kernel/rpcPacket.h>
  32. #include <kernel/rpcCltStat.h>
  33. #include <kernel/rpcHistogram.h>
  34. #endif /* KERNEL */
  35.  
  36.  
  37. /*
  38.  * Tunable parameters used by Rpc_Call.  They are packaged up here so
  39.  * the values can be set/reported conveniently.
  40.  */
  41. typedef struct RpcConst {
  42.     /*
  43.      * The initial wait period is defined by retryWait, in ticks.  It
  44.      * is initialized from the millisecond valued retryMsec.  This is
  45.      * how long we wait after sending the first request packet.  If
  46.      * we are sending a fragmented packet we have a longer retry period.
  47.      */
  48.     int          retryMsec;
  49.     unsigned int     retryWait;
  50.     int          fragRetryMsec;
  51.     unsigned int    fragRetryWait;
  52.     /*
  53.      * The wait period increases if we have to resend.  If we are recieving
  54.      * acknowledgments then we increase the timout until maxAckWait (ticks),
  55.      * which is initialized from maxAckMsec.  If we are not getting acks
  56.      * then we still back off a bit (as a heuristic in case  we are talking
  57.      * to a slow host) until the timout period is maxTimeoutWait, which
  58.      * is initialized from maxTimeoutMsec.
  59.      */
  60.     int          maxAckMsec;
  61.     unsigned int    maxAckWait;
  62.     int          maxTimeoutMsec;
  63.     unsigned int    maxTimeoutWait;
  64.     /*
  65.      * maxTries is the maximum number of times we resend a request
  66.      * without getting any response (i.e. acknowledgments or the reply).
  67.      * maxAcks is the maximum number of acknowledgments we'll receive
  68.      * before complaining "so and so seems hung".  In the case of a
  69.      * broadcast rpc, we'll abort the RPC after maxAcks acknowledgments.
  70.      */
  71.     int         maxTries;
  72.     int         maxAcks;
  73. } RpcConst;
  74.  
  75. /*
  76.  * Two sets of timeouts are defined, one for local ethernet, one for IP.
  77.  */
  78. extern RpcConst rpcEtherConst;
  79. extern RpcConst rpcInetConst;
  80.  
  81.  
  82. /*
  83.  * Global used by Rpc_Call and initialized by Rpc_Start.  This is set
  84.  * once at boot-time to the real time clock.  The servers track this value
  85.  * and detects a reboot by us when this changes.  Note that if the boot
  86.  * ID is zero then the server doesn't attempt to detect a reboot.  Thus
  87.  * we can use a GET_TIME RPC in order to set this.  See Rpc_Start.
  88.  */
  89. extern unsigned int rpcBootId;
  90.  
  91.  
  92. /*
  93.  *      An RPC channel is described here.  It is used during an RPC to
  94.  *      keep the state of the RPC.  Between uses the channel carries over
  95.  *      some information to use as hints in subsequent transactions.
  96.  */
  97. typedef struct RpcClientChannel {
  98.     /*
  99.      * The Channel Index is a self reference to this channel.
  100.      * It is this channels index in the array of channel pointers.
  101.      * It is kept here because it will be part of the packet header.
  102.      */
  103.     int            index;
  104.     /*
  105.      * Rpc transaction state:  There are state bits to drive the algorithm,
  106.      * the values are described below with their definitions.
  107.      */
  108.     int            state;
  109.     /*
  110.      * The ID of the server the channel is being used with.
  111.      * A value of -1 means the channel has not been used yet.
  112.      */
  113.     int            serverID;
  114.     /*
  115.      * These timeout parameters depend on the server being used.
  116.      */
  117.     RpcConst        *constPtr;
  118.     /*
  119.      * A channel may wait on input, and be taken out of the timeout queue
  120.      * at interrupt time.  The timer queue element is stored here so
  121.      * it is accessable by the interrupt time routine.
  122.      */
  123.     Timer_QueueElement timeoutItem;
  124.     /*
  125.      * RpcDoCall and RpcClientDispatch synchronize with a master lock.
  126.      * The interrupt level routine notifies waitCondition when the waiting
  127.      * process should wakeup and check for input.
  128.      */
  129.     Sync_Semaphore    mutex;
  130.     Sync_Condition    waitCondition;
  131.     /*
  132.      * This bitmask indicates which fragments in the current
  133.      * request message the server has received.
  134.      */
  135.     int            fragsDelivered;
  136.     /*
  137.      * This bitmask indicates which fragments in the current reply
  138.      * message we have received.
  139.      */
  140.     int            fragsReceived;
  141.     /*
  142.      * Two temporaries are needed to record the
  143.      * amount of data actually returned by the server.
  144.      */
  145.     int            actualDataSize;
  146.     int            actualParamSize;
  147.     /*
  148.      * The header and buffer specifications for the request message.
  149.      */
  150.     RpcHdr        requestRpcHdr;
  151.     RpcBufferSet    request;
  152.     /*
  153.      * An array of RPC headers and buffer sets that are used when fragmenting
  154.      * a request message.
  155.      */
  156.     RpcHdr        fragRpcHdr[RPC_MAX_NUM_FRAGS];
  157.     RpcBufferSet    fragment[RPC_MAX_NUM_FRAGS];
  158.  
  159.     /*
  160.      * Header and buffer specification for the reply message.
  161.      */
  162.     RpcHdr        replyRpcHdr;
  163.     RpcBufferSet    reply;
  164.     /*
  165.      * The header and buffer specifications for the explicit acknowledgments.
  166.      */
  167.     RpcHdr        ackHdr;
  168.     RpcBufferSet    ack;
  169. } RpcClientChannel;
  170.  
  171. /*
  172.  * Definitions of state bits for a remote procedure call.
  173.  *  CHAN_FREE        The channel is free.
  174.  *  CHAN_BUSY        The channel is in use.
  175.  *  CHAN_WAITING    The channel available for input.
  176.  *  CHAN_INPUT        The channel has received input.
  177.  *  CHAN_TIMEOUT    The channel is in the timeout queue.
  178.  *  CHAN_FRAGMENTING    The channel is awaiting fragment reassembly.
  179.  */
  180. #define CHAN_FREE        0x40
  181. #define CHAN_BUSY        0x01
  182. #define CHAN_WAITING        0x02
  183. #define CHAN_INPUT        0x04
  184. #define CHAN_TIMEOUT        0x08
  185. #define CHAN_FRAGMENTING    0x10
  186.  
  187. /*
  188.  * The set of channels is dynamically allocated at boot time and
  189.  * they are referenced through an array of pointers.
  190.  */
  191. extern RpcClientChannel **rpcChannelPtrPtr;
  192. extern int          rpcNumChannels;
  193.  
  194. /*
  195.  * These are variables to control handling of negative acknowledgement
  196.  * back-off on the clients.  Maybe they should be in the client channel
  197.  * state?  But there's no server state associated with the negative ack,
  198.  * so this wouldn't necessarily make sense.
  199.  */
  200. extern    int    rpcNackRetryWait;
  201. extern    int    rpcMaxNackWait;
  202.  
  203. /* Whether or not client ramps down channels in response to a neg. ack. */
  204. extern    Boolean    rpcChannelNegAcks;
  205.  
  206. /*
  207.  * A histogram of the call times for the different RPCs.
  208.  */
  209. extern Rpc_Histogram    *rpcCallTime[];
  210.  
  211. /*
  212.  * A raw count of the number of rpc calls.
  213.  */
  214. extern int        rpcClientCalls[];
  215.  
  216. /*
  217.  * Forward declarations.
  218.  */
  219. extern void RpcChanFree _ARGS_((RpcClientChannel *chanPtr));
  220. extern void RpcChanClose _ARGS_((register RpcClientChannel *chanPtr, register RpcHdr *rpcHdrPtr));
  221. extern void RpcSetup _ARGS_((int serverID, int command, register Rpc_Storage *storagePtr, register RpcClientChannel *chanPtr));
  222. extern RpcClientChannel *RpcChanAlloc _ARGS_((int serverID));
  223. extern ReturnStatus RpcDoCall _ARGS_((int serverID, register RpcClientChannel *chanPtr, Rpc_Storage *storagePtr, int command, unsigned int *srvBootIDPtr, int *notActivePtr, unsigned int *recovTypePtr));
  224. extern void RpcClientDispatch _ARGS_((register RpcClientChannel *chanPtr, register RpcHdr *rpcHdrPtr));
  225. extern void RpcInitServerChannelState _ARGS_((void));
  226.  
  227.  
  228. #endif /* _RPCCLIENT */
  229.